/*
-----------------------------------------------------------------------------
This source file is part of SapphireEngine

SapphireEngine is a Framework for Turn Based Strategy games.
For more information see http://code.google.com/p/sapphire-engine/

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.

-----------------------------------------------------------------------------
*/
#ifndef _SAPPHIRE_TYPE_DEFS_H
#define _SAPPHIRE_TYPE_DEFS_H

#include <OgrePrerequisites.h>
#include <OgreString.h>
#include <CEGUI.h>

//#include "SapphireMemoryManager.h"

namespace SapphireEngine
{
	using std::vector;
	using std::pair;

	using namespace Ogre;
	using namespace CEGUI;

	// Pre-declare classes
	// Allows use of pointers in header files without including individual .h
	// so decreases dependencies between files
 	class SapphireEngineApp;
	class SapphireMemoryManager;
	namespace Core
	{
		class Body;
		class CoreManager;
		class GameFactor;
		class Movement;
		class Part;
		class PartNode;
		class Technology;
		class Weapon;
	}
	namespace GUI
	{
 		class GUIManager;
 		class LoadingScreen;
 		class LoadingScreenThread;
 		class MainMenuScreen;
 		class PartTool;
		class Screen;
		class ScreenListener;
	}
	using namespace Core;
	using namespace GUI;

	/// Type definition for Ogre::String vector
	typedef vector<Ogre::String> StringArray;
	/// Type definition for Ogre::String vector iterator
	typedef vector<Ogre::String>::iterator StringArrayIterator;
	/// Type definition for Ogre::String vector const iterator
	typedef vector<Ogre::String>::const_iterator StringArrayConstIterator;

	/// Type definition for Core::PartNode vector
	typedef vector<PartNode*> PartNodeArray;
	/// Type definition for Core::PartNode vector iterator
	typedef vector<PartNode*>::iterator PartNodeArrayIterator;
	/// Type definition for Core::PartNode vector const iterator
	typedef vector<PartNode*>::const_iterator PartNodeArrayConstIterator;

	/// Type definition for Ogre::String hash_set
	typedef HashSet<Ogre::String> StringSet;
	/// Type definition for Ogre::String hash_set iterator
	typedef HashSet<Ogre::String>::iterator StringSetIterator;
	/// Type definition for Ogre::String hash_set const iterator
	typedef HashSet<Ogre::String>::const_iterator StringSetConstIterator;

	/// Type definition for int, Technology* hash_map
	typedef HashMap<int, Technology*> TechnologyMap;
	/// Type definition for int, Technology* hash_map iterator
	typedef HashMap<int, Technology*>::iterator TechnologyMapIterator;
	/// Type definition for int, Technology* hash_map const iterator
	typedef HashMap<int, Technology*>::const_iterator TechnologyMapConstIterator;
	/// Type definition for int, Technology* pair
	typedef pair<int, Technology*> TechnologyMapItem;

	/// Type definition for int, Part* hash_map
	typedef HashMap<int, Part*> PartMap;
	/// Type definition for int, Part* hash_map iterator
	typedef HashMap<int, Part*>::iterator PartMapIterator;
	/// Type definition for int, Part* hash_map const iterator
	typedef HashMap<int, Part*>::const_iterator PartMapConstIterator;
	/// Type definition for int, Part* pair
	typedef pair<int, Part*> PartMapItem;

	/// Type definition for Ogre::String, long hash_map
	typedef HashMap<Ogre::String, long> GameFactorMap;
	/// Type definition for Ogre::String, long hash_map iterator
	typedef HashMap<Ogre::String, long>::iterator GameFactorMapIterator;
	/// Type definition for Ogre::String, long hash_map const iterator
	typedef HashMap<Ogre::String, long>::const_iterator GameFactorMapConstIterator;
	/// Type definition for Ogre::String, long pair
	typedef pair<Ogre::String, long> GameFactorMapItem;

	/// Type definition for Ogre::String, long hash_map
	typedef HashMap<Ogre::String, Screen*> ScreenMap;
	/// Type definition for Ogre::String, long hash_map iterator
	typedef HashMap<Ogre::String, Screen*>::iterator ScreenMapIterator;
	/// Type definition for Ogre::String, long hash_map const iterator
	typedef HashMap<Ogre::String, Screen*>::const_iterator ScreenMapConstIterator;
	/// Type definition for Ogre::String, long pair
	typedef pair<Ogre::String, Screen*> ScreenMapItem;

	/// Type definition for CoreManager
	#define  getCoreManager CoreManager::getSingletonPtr
	/// Type definition for GUIManager
	#define  getGUIManager GUIManager::getSingletonPtr
	/// Type definition for WindowManager;
	#define getWindowManager CEGUI::WindowManager::getSingletonPtr

	#define getSystem CEGUI::System::getSingletonPtr 
}
#endif